﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Net.Sockets;
//using System.Net;

//namespace ControleEstoque.Entidades
//{
//    public class Reader6B : Reader
//    {
//        public string ip;
//        public int port;
//        private NetworkStream networkstream;

//        public override bool Connect(string addr, int portn)
//        {
//            ip = addr;
//            port = portn;
//            try
//            {
//                IPEndPoint ipend = new IPEndPoint(IPAddress.Parse(addr), port);
//                Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//                server.Connect(ipend);
//                networkstream = new NetworkStream(server);
//                ConfigReaderSys();
//                Connected = true;
//                return true;

//            }
//            catch
//            {
//                return false;
//            }
//        }

//        public override bool Disconnect()
//        {
//            try
//            {
//                if (Connected)
//                {
//                    PowerAmplifier("off");
//                    networkstream.Close();
//                    Connected = false;
//                }
//                return true;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        public override bool SetReadLoop(byte antenna)
//        {
//            byte[] read_loop = { 0x00, 0x03, 0x71, 0x00, 0x01, 0xba, 0xd1 };
//            try
//            {
//                if (antenna != 0)
//                {
//                    read_loop[3] = antenna;
//                    Checksum(read_loop, 5);
//                }
//                networkstream.Write(read_loop, 0, read_loop.Length);
//                loop = true;
//                return true;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        public override string Read()
//        {
//            byte[] buff = new byte[15];
//            byte[] crc = new byte[15];

//            try
//            {
//                if (loop && networkstream.DataAvailable)
//                {
//                    buff = GivemeWhatINeed(0x71);
//                    /* ERROR CHECK */
//                    if (buff[3] == 0)
//                    {
//                        /* Checksum */
//                        crc = buff;
//                        Checksum(crc, 13);
//                        return Misc.Equals(crc, buff) ? Misc.PrintTag(buff, 15) : null;
//                    }
//                }
//                return null;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        public override string ReadData(string tid, byte startaddr, byte datalength, byte antenna)
//        {
//            byte[] read_data = { 0x00, 0x0c, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0xc8 };
//            byte[] tagid = new byte[8];
//            byte[] buff = new byte[7 + datalength];
//            string ax = null;
//            int size, i;

//            try
//            {
//                startaddr += 8;
//                tagid = Misc.GetBytes(tid, 8);
//                read_data[3] = antenna;
//                read_data[12] = startaddr;
//                read_data[13] = datalength;
//                for (i = 0; i < tagid.Length; i++)
//                    read_data[4 + i] = tagid[i];
//                Checksum(read_data, 14);
//                networkstream.Write(read_data, 0, read_data.Length);
//                buff = GivemeWhatINeed(0x72);
//                if (buff[3] == 0)
//                {
//                    // TODO: Use buff[0] and buff[1] to calculate the size
//                    size = buff[1] + 4; // Size with header

//                    string tmp = Misc.PrintTag(buff, size).Replace(" ", "");
//                    if (tmp.Length >= (10 + (datalength * 2)))
//                        ax = tmp.Substring(10, datalength * 2);
//                }
//                return ax;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        public override bool WriteData(string tid, byte startaddr, byte antenna, string sdata)
//        {
//            int datalength = (int)System.Math.Ceiling((double)sdata.Length / 2);
//            byte[] write_data = new byte[16 + datalength];
//            byte[] header = { 0x00, 0x0c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
//            byte[] tagid = new byte[8];
//            byte[] buff = new byte[7];
//            byte[] data;
//            int i;

//            try
//            {
//                startaddr += 8;
//                tagid = Misc.GetBytes(tid, 8);
//                data = Misc.GetBytes(sdata, datalength);
//                header[3] = antenna;
//                header[12] = startaddr;
//                header[13] = (byte)datalength;
//                for (i = 0; i < tagid.Length; i++)
//                    header[4 + i] = tagid[i];
//                System.Buffer.BlockCopy(header, 0, write_data, 0, header.Length);
//                for (i = 0; i < data.Length; i++)
//                    write_data[14 + i] = data[i];
//                write_data[1] = (byte)(write_data.Length - 4);
//                Checksum(write_data, write_data.Length - 2);
//                networkstream.Write(write_data, 0, write_data.Length);
//                buff = GivemeWhatINeed(0x73);
//                return buff[3] == 0x00 ? true : false;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        private bool ConfigReaderSys()
//        {
//            byte[] config_reader_sys = { 0x00, 0x04, 0x63, 0x02, 0x01, 0x04, 0x3b, 0xc1 };
//            byte[] buff = new byte[6];

//            try
//            {
//                networkstream.Write(config_reader_sys, 0, config_reader_sys.Length);
//                buff = GivemeWhatINeed(0x63);
//                return buff[3] == 0x00 ? true : false;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }

//        public override bool PowerAmplifier(string onoff, byte antenna)
//        {
//            byte[] off = { 0x00, 0x01, 0x61, 0x07, 0x46 };
//            byte[] on = { 0x00, 0x02, 0x60, 0x01, 0x46, 0x28 };
//            byte[] ack = new byte[6];

//            try
//            {
//                switch (onoff)
//                {
//                    case "on":
//                        on[3] = antenna;
//                        Checksum(on, 4);
//                        networkstream.Write(on, 0, on.Length);
//                        ack = GivemeWhatINeed(0x60);
//                        return ack[3] == 0x00 ? true : false;
//                    case "off":
//                        networkstream.Write(off, 0, off.Length);
//                        networkstream.Write(off, 0, off.Length);
//                        clear();
//                        networkstream.Write(off, 0, off.Length);
//                        ack = GivemeWhatINeed(0x61);
//                        if (ack[3] == 0)
//                        {
//                            loop = false;
//                            return true;
//                        }
//                        break;
//                }
//                return false;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }

//        }

//        /* Give me or die. */
//        private byte[] GivemeWhatINeed(byte mustbe)
//        {
//            // TODO: Usar buff[0] e buff[1] para o calculo do size
//            byte[] header = new byte[3];
//            byte[] buff = { 0xFF, 0xFF, 0xFF, 0xFF };
//            byte[] tmp;
//            int size = 0;
//            long cnt = 0;
//            try
//            {
//                do
//                {
//                    if (networkstream.DataAvailable)
//                    {
//                        networkstream.Read(header, 0, 3);
//                        size = header[1] + 1;
//                        tmp = new byte[size];
//                        networkstream.Read(tmp, 0, size);
//                        buff = new byte[header.Length + size];
//                        System.Buffer.BlockCopy(header, 0, buff, 0, header.Length);
//                        System.Buffer.BlockCopy(tmp, 0, buff, 3, tmp.Length);
//                        cnt = 0;
//                    }
//                    else
//                    {
//                        cnt++;
//                    }
//                } while (header[2] != mustbe && cnt < 3000000);
//                return buff;
//            }
//            catch (Exception ex)
//            {
//                throw ex;
//            }
//        }
//        private void Clear()
//        {
//            byte[] tmp = new byte[1024];
//            while (networkstream.DataAvailable)
//            {
//                networkstream.Read(tmp, 0, 1024);
//            }
//        }

//        public override string Read(int num, byte antenna)
//        {
//            throw new NotImplementedException();
//        }

//        public override bool Write(string epcn)
//        {
//            throw new NotImplementedException();
//        }

//        public override bool Write(string epcn, string password)
//        {
//            throw new NotImplementedException();
//        }
//    }
//}
